#include "../source/server.hpp"

// void HandleClose(Channel *channel)
// {
//     std::cout << "close: " << channel->Fd() << std::endl;
//     channel->Remove();
//     delete channel;
// }

// void HandleRead(Channel *channel)
// {
//     int fd = channel->Fd();
//     char buffer[1024] = {0};
//     ssize_t n = recv(fd, buffer, sizeof(buffer) - 1, 0);
//     if (n <= 0)
//     {
//         return HandleClose(channel);
//     }

//     buffer[n] = 0;
//     std::cout << "recv message: " << buffer << std::endl;

//     // 启动可写事件监控
//     channel->EnableWrite();
// }

// void HandleWrite(Channel *channel)
// {
//     int fd = channel->Fd();
//     std::string message = "hello client";
//     ssize_t n = send(fd, message.c_str(), message.size(), 0);
//     if (n < 0)
//     {
//         return HandleClose(channel);
//     }

//     // 关闭写监控
//     channel->DisableWrite();
// }

// void HandleError(Channel *channel)
// {
//     return HandleClose(channel);
// }

// void HandleEvent(EventLoop *loop, Channel *channel, const uint64_t &timerid)
// {
//     loop->TimerRefresh(timerid);
// }

// 管理所有连接
std::unordered_map<uint64_t, PtrConnection> _conns;
uint64_t conn_id = 0;
EventLoop base_loop;
LoopThreadPool* loop_pool;

// std::vector<LoopThread> threads(2);
// int next_loop = 0;

void ConnectionDestroy(const PtrConnection &conn)
{
    _conns.erase(conn->Id());
}

void OnConnected(const PtrConnection &conn)
{
    DLOG("new connection: %p", conn.get());
}

void OnMessage(const PtrConnection &conn, Buffer *buf)
{
    DLOG("%s", buf->ReadPosition());
    buf->MoveReadOffset(buf->ReadAbleSize());
    std::string str = "hello world";
    conn->Send(str.c_str(), str.size());
    conn->Shutdown();
}

// void Acceptor(EventLoop *loop, Channel *listenchannel)
// {
//     DLOG("1111");
//     int fd = listenchannel->Fd();
//     int newfd = accept(fd, nullptr, nullptr);
//     if (newfd < 0)
//     {
//         std::cout << "accept socketfd failed" << std::endl;
//     }

//     conn_id++;
//     PtrConnection conn(new Connection(loop, conn_id, newfd));
//     conn->SetMessageCallback(std::bind(OnMessage, std::placeholders::_1, std::placeholders::_2));
//     conn->SetSrvClosedCallback(std::bind(ConnectionDestroy, std::placeholders::_1));
//     conn->SetConnectedCallback(std::bind(OnConnected, std::placeholders::_1));
//     conn->EnableInactiveRelease(10); // 启动非活跃超时销毁
//     conn->Established();             // 就绪初始化
//     _conns.insert(std::make_pair(conn_id, conn));

//     // uint64_t timerid = rand() % 10000;
//     // Channel *channel = new Channel(loop, newfd);
//     // // 为通信套接字设置可读事件的回调函数
//     // channel->SetReadCallback(std::bind(HandleRead, channel));
//     // // 为通信套接字设置可写事件的回调函数
//     // channel->SetWriteCallback(std::bind(HandleWrite, channel));
//     // // 为通信套接字设置关闭连接事件的回调函数
//     // channel->SetCloseCallback(std::bind(HandleClose, channel));
//     // // 为通信套接字设置错误事件的回调函数
//     // channel->SetErrorCallback(std::bind(HandleError, channel));
//     // // 为通信套接字设置任意事件的回调函数
//     // channel->SetEventCallback(std::bind(HandleEvent, loop, channel, timerid));

//     // 非活跃连接的超时释放操作,10秒后关闭连接
//     // 定时销毁任务必须在读事件之前,可能启动事件监控后,立即有了事件,但是这时候还没有任务
//     // loop->TimerAdd(timerid, 10, std::bind(HandleClose, channel));

//     // 通信套接字启动可读
//     // channel->EnableRead();
// }

void NewConnection(int fd)
{
    conn_id++;
    PtrConnection conn(new Connection(loop_pool->GetNextLoop(), conn_id, fd));
    conn->SetMessageCallback(std::bind(OnMessage, std::placeholders::_1, std::placeholders::_2));
    conn->SetSrvClosedCallback(std::bind(ConnectionDestroy, std::placeholders::_1));
    conn->SetConnectedCallback(std::bind(OnConnected, std::placeholders::_1));
    conn->EnableInactiveRelease(10); // 启动非活跃超时销毁
    conn->Established();             // 就绪初始化
    _conns.insert(std::make_pair(conn_id, conn));
}

int main()
{
    // srand(time(nullptr));

    loop_pool = new LoopThreadPool(&base_loop);
    loop_pool->SetThreadCount(2);
    loop_pool->Create();
    Acceptor acceptor(&base_loop, 8080);
    acceptor.SetAcceptCallback(std::bind(NewConnection, std::placeholders::_1));
    acceptor.Listen();
    base_loop.Start();
    return 0;
}
// int main()
// {
//     srand(time(nullptr));

//     Socket listensock;
//     listensock.CreateServer(8080);
//     EventLoop loop;

//     // 为listen套接字创建一个Channel对象进行事件监控，以及事件的处理
//     Channel channel(&loop, listensock.Fd());

//     // 回调中,获取新连接，为新连接创建Channel并添加监控
//     channel.SetReadCallback(std::bind(Acceptor, &loop, &channel));

//     // 启动可读数据监控
//     channel.EnableRead();

//     while (true)
//     {
//         loop.Start();
//     }

//     listensock.Close();
//     return 0;
// }

// int main()
// {
//     Socket listensock;
//     listensock.CreateServer(8080);
//     while (true)
//     {
//         int newfd = listensock.Accept();
//         if (newfd < 0)
//         {
//             continue;
//         }
//         Socket clientsock(newfd);
//         char buffer[1024];
//         int ret = clientsock.Recv(buffer, sizeof(buffer) - 1, 0);
//         if (ret < 0)
//         {
//             clientsock.Close();
//             continue;
//         }
//         buffer[ret] = 0;
//         std::cout << buffer << std::endl;
//         clientsock.Send(buffer, ret);
//         clientsock.Close();
//     }
//     listensock.Close();
//     return 0;
// }




